home *** CD-ROM | disk | FTP | other *** search
/ Linux Cubed Series 8: LINUX Games / Linux Cubed Series 8 - LINUX Games.iso / games / x11 / rpg / crossfir.92 / crossfir / crossfire-0.92.5 / server / c_misc.c < prev    next >
C/C++ Source or Header  |  1996-07-24  |  16KB  |  594 lines
  1. /*
  2.  * static char *rcsid_c_misc_c =
  3.  *   "$Id: c_misc.c,v 1.13 1996/01/02 11:30:27 master Exp $";
  4.  */
  5.  
  6. /*
  7.     CrossFire, A Multiplayer game for X-windows
  8.  
  9.     Copyright (C) 1992 Mark Wedel
  10.     Copyright (C) 1992 Frank Tore Johansen
  11.  
  12.     This program is free software; you can redistribute it and/or modify
  13.     it under the terms of the GNU General Public License as published by
  14.     the Free Software Foundation; either version 2 of the License, or
  15.     (at your option) any later version.
  16.  
  17.     This program is distributed in the hope that it will be useful,
  18.     but WITHOUT ANY WARRANTY; without even the implied warranty of
  19.     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  20.     GNU General Public License for more details.
  21.  
  22.     You should have received a copy of the GNU General Public License
  23.     along with this program; if not, write to the Free Software
  24.     Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  25.  
  26.     The author can be reached via e-mail to master@rahul.net
  27. */
  28. #include <global.h>
  29. #include <loader.h>
  30. #ifndef __CEXTRACT__
  31. #include <sproto.h>
  32. #endif
  33.  
  34.  
  35. /* Handles misc. input request - things like hash table, malloc, maps,
  36.  * who, etc.
  37.  */
  38.  
  39. void map_info(object *op) {
  40.   mapstruct *m;
  41.   char buf[MAX_BUF], map_path[MAX_BUF];
  42.   long sec = seconds();
  43. #ifdef MAP_RESET
  44.   new_draw_info_format(NDI_UNIQUE, 0, op,
  45.     "Current time is: %02ld:%02ld:%02ld.",
  46.       (sec%86400)/3600,(sec%3600)/60,sec%60);
  47.   new_draw_info(NDI_UNIQUE, 0,op,"Path               Pl PlM IM   TO Dif Pen Reset");
  48. #else
  49.   new_draw_info(NDI_UNIQUE, 0,op,"Pl Pl-M IM   TO Dif Pen");
  50. #endif
  51.   for(m=first_map;m!=NULL;m=m->next) {
  52. #ifndef MAP_RESET
  53.     if (m->in_memory == MAP_SWAPPED)
  54.       continue;
  55. #endif
  56.     /* Print out the last 18 characters of the map name... */
  57.     if (strlen(m->path)<=18) strcpy(map_path, m->path);
  58.     else strcpy(map_path, m->path + strlen(m->path) - 18);
  59. #ifndef MAP_RESET
  60.       sprintf(buf,"%-18.18s %2ld %2d   %1ld %4ld %2ld  %2d",
  61.               map_path, m->players,players_on_map(m),m->in_memory,m->timeout,
  62.               m->difficulty, count_pending(m));
  63. #else
  64.       sprintf(buf,"%-18.18s %2d %2d   %1d %4d %2d  %2d %02ld:%02ld:%02ld",
  65.               map_path, m->players,players_on_map(m),
  66.               m->in_memory,m->timeout,m->difficulty, count_pending(m),
  67.               (m->reset_time%86400)/3600,(m->reset_time%3600)/60,
  68.               m->reset_time%60);
  69. #endif
  70.     new_draw_info(NDI_UNIQUE, 0,op,buf);
  71.   }
  72. }
  73.  
  74. int command_spell_reset(object *op, char *params)
  75. {
  76.     init_spell_param();
  77.     return 1;
  78. }
  79.  
  80. int command_motd(object *op, char *params)
  81. {
  82.     display_motd(op);
  83.     return 1;
  84. }
  85.  
  86. int command_bug(object *op, char *params)
  87. {
  88.     char buf[MAX_BUF];
  89.  
  90.     if (params == NULL) {
  91.       new_draw_info(NDI_UNIQUE, 0,op,"what bugs?");
  92.       return 1;
  93.     }
  94.     if (op == NULL) {
  95.       strcpy(buf,active_socket->name);
  96.       strcat(buf," bug reports: ");
  97.     } else {
  98.       strcpy(buf,op->name);
  99.       strcat(buf," bug-reports: ");
  100.     }
  101.     strncat(buf,++params,MAX_BUF - strlen(buf) );
  102.     buf[MAX_BUF - 1] = '\0';
  103.     bug_report(buf);
  104.     LOG(llevError,"%s\n",buf);
  105.     new_draw_info(NDI_ALL | NDI_UNIQUE, 1, NULL, buf);
  106.     new_draw_info(NDI_UNIQUE, 0,op, "OK, thanks!");
  107.     return 1;
  108. }
  109.  
  110.  
  111. void malloc_info(object *op) {
  112.   int ob_used=count_used(),ob_free=count_free(),players,nrofmaps;
  113.   int nrm=0,mapmem=0,anr,anims,sum_alloc=0,sum_used=0,i,j,tlnr, alnr;
  114.   treasurelist *tl;
  115.   player *pl;
  116.   mapstruct *m;
  117.   archetype *at;
  118.   artifactlist *al;
  119.  
  120.   for(tl=first_treasurelist,tlnr=0;tl!=NULL;tl=tl->next,tlnr++);
  121.   for(al=first_artifactlist, alnr=0; al!=NULL; al=al->next, alnr++);
  122.  
  123.   for(at=first_archetype,anr=0,anims=0;at!=NULL;
  124.       at=at->more==NULL?at->next:at->more,anr++)
  125.     if(at->faces!=NULL)
  126.       anims+=at->animations+1;
  127.   for(pl=first_player,players=0;pl!=NULL;pl=pl->next,players++);
  128.   for(m=first_map,nrofmaps=0;m!=NULL;m=m->next,nrofmaps++)
  129.     if(m->in_memory == MAP_IN_MEMORY)
  130.       mapmem+=m->mapx*m->mapy*(sizeof(object *)+sizeof(unsigned char *)*2),
  131.       nrm++;
  132.   sprintf(errmsg,"Sizeof: object=%ld  player=%ld  map=%ld",
  133.           (long)sizeof(object),(long)sizeof(player),(long)sizeof(mapstruct));
  134.   new_draw_info(NDI_UNIQUE, 0,op,errmsg);
  135.   sprintf(errmsg,"%4d used objects:    %8d",ob_used,i=(ob_used*sizeof(object)));
  136.   new_draw_info(NDI_UNIQUE, 0,op,errmsg);
  137.   sum_used+=i;  sum_alloc+=i;
  138.   sprintf(errmsg,"%4d free objects:    %8d",ob_free,i=(ob_free*sizeof(object)));
  139.   new_draw_info(NDI_UNIQUE, 0,op,errmsg);
  140.   sprintf(errmsg,"%4d active objects:  %8d",count_active(), 0);
  141.   new_draw_info(NDI_UNIQUE, 0,op,errmsg);
  142.   sum_alloc+=i;
  143.   sprintf(errmsg,"%4d players:         %8d",players,i=(players*sizeof(player)));
  144.   new_draw_info(NDI_UNIQUE, 0,op,errmsg);
  145.   sum_alloc+=i; sum_used+=i;
  146.   for(pl=first_player,i=0;pl!=NULL;pl=pl->next)
  147.     i+=pl->infolines*pl->infochars*sizeof(char)+
  148.        pl->inv_chars*pl->inv_size*sizeof(char)+
  149.        pl->look_chars*pl->look_size*sizeof(char);
  150.   sprintf(errmsg,"%4d player windows:  %8d",players*3,i);
  151.   new_draw_info(NDI_UNIQUE, 0,op,errmsg);
  152.   sum_alloc+=i; sum_used+=i;
  153.   for(pl=first_player,i=0,j=0;pl!=NULL;pl=pl->next)
  154.     if(pl->pixmaps!=NULL)
  155.       i+=nrofpixmaps*sizeof(Pixmap), j++;
  156.   sprintf(errmsg,"%4d pixmap sets:     %8d",j,i);
  157.   new_draw_info(NDI_UNIQUE, 0,op,errmsg),
  158.   sum_alloc+=i; sum_used+=i;
  159.   sprintf(errmsg,"%4d maps allocated:  %8d",nrofmaps,
  160.           i=(nrofmaps*sizeof(mapstruct)));
  161.   new_draw_info(NDI_UNIQUE, 0,op,errmsg);
  162.   sum_alloc+=i;  sum_used+=nrm*sizeof(mapstruct);
  163.   sprintf(errmsg,"%4d maps in memory:  %8d",nrm,mapmem);
  164.   new_draw_info(NDI_UNIQUE, 0,op,errmsg);
  165.   sum_alloc+=mapmem; sum_used+=mapmem;
  166.   sprintf(errmsg,"%4d archetypes:      %8d",anr,i=(anr*sizeof(archetype)));
  167.   new_draw_info(NDI_UNIQUE, 0,op,errmsg);
  168.   sum_alloc+=i; sum_used+=i;
  169.   sprintf(errmsg,"%4d animations:      %8d",anims,i=(anims*sizeof(Fontindex)));
  170.   new_draw_info(NDI_UNIQUE, 0,op,errmsg);
  171.   sum_alloc+=i; sum_used+=i;
  172.   sprintf(errmsg,"%4d spells:          %8d",NROFREALSPELLS,
  173.           i=(NROFREALSPELLS*sizeof(spell)));
  174.   new_draw_info(NDI_UNIQUE, 0,op,errmsg);
  175.   sum_alloc+=i; sum_used+=i;
  176.   sprintf(errmsg,"%4d treasurelists    %8d",tlnr,i=(tlnr*sizeof(treasurelist)));
  177.   new_draw_info(NDI_UNIQUE, 0,op,errmsg);
  178.   sum_alloc+=i; sum_used+=i;
  179.   sprintf(errmsg,"%4ld treasures        %8d",nroftreasures,
  180.           i=(nroftreasures*sizeof(treasure)));
  181.   new_draw_info(NDI_UNIQUE, 0,op,errmsg);
  182.   sum_alloc+=i; sum_used+=i;
  183.   sprintf(errmsg,"%4ld artifacts        %8d", nrofartifacts,
  184.           i=(nrofartifacts*sizeof(artifact)));
  185.   new_draw_info(NDI_UNIQUE, 0,op, errmsg);
  186.   sum_alloc+=i; sum_used +=i;
  187.   sprintf(errmsg,"%4ld artifacts strngs %8d", nrofallowedstr,
  188.           i=(nrofallowedstr*sizeof(linked_char)));
  189.   new_draw_info(NDI_UNIQUE, 0,op, errmsg);
  190.   sum_alloc += i;sum_used+=i;
  191.   sprintf(errmsg,"%4d artifactlists    %8d",alnr,i=(alnr*sizeof(artifactlist)));
  192.   new_draw_info(NDI_UNIQUE, 0,op,errmsg);
  193.   sum_alloc += i; sum_used += i;
  194.  
  195.   sprintf(errmsg,"Total space allocated:%8d",sum_alloc);
  196.   new_draw_info(NDI_UNIQUE, 0,op,errmsg);
  197.   sprintf(errmsg,"Total space used:     %8d",sum_used);
  198.   new_draw_info(NDI_UNIQUE, 0,op,errmsg);
  199. }
  200.  
  201. int count_pending(mapstruct *map) {
  202.   objectlink *obl;
  203.   int i;
  204.  
  205.   for(i=0, obl = map->pending; obl != NULL; obl = obl->next)
  206.     i++;
  207.   return i;
  208. }
  209.  
  210. void current_map_info(object *op) {
  211.     mapstruct *m = op->map;
  212.  
  213.     if (!m)
  214.     return;
  215.  
  216.     new_draw_info_format(NDI_UNIQUE, 0,op,   
  217.     "%s (%s)", m->map_object->name, m->path);
  218.  
  219.     if (QUERY_FLAG(op,FLAG_WIZ)) {
  220.     new_draw_info_format(NDI_UNIQUE, 0, op,
  221.         "players:%d difficulty:%d size:%dx%d start:%dx%d timeout %ld", 
  222.          m->players, m->difficulty, 
  223.          m->mapx, m->mapy, 
  224.          EXIT_X(m->map_object), EXIT_Y(m->map_object),
  225.          MAP_TIMEOUT(m));
  226.  
  227.     }
  228.     if (m->map_object->msg)
  229.     new_draw_info(NDI_UNIQUE, NDI_NAVY, op, m->map_object->msg);
  230. }
  231.  
  232. #ifdef DEBUG_MALLOC_LEVEL
  233. int command_malloc_verify(object *op, char *parms)
  234. {
  235.     extern int malloc_verify(void);
  236.  
  237.     if (!malloc_verify()) 
  238.         new_draw_info(NDI_UNIQUE, 0,op,"Heap is corrupted.");
  239.     else
  240.         new_draw_info(NDI_UNIQUE, 0,op,"Heap checks out OK.");
  241.     return 1;
  242. }
  243. #endif
  244.  
  245. int command_who (object *op, char *params)
  246. {
  247.     player *pl;
  248. #ifdef SERVER
  249.     sockets *s;
  250. #endif /* SERVER */
  251.   char buf[MAX_BUF];
  252.  
  253.     if (first_player != (player *) NULL)
  254.       new_draw_info(NDI_UNIQUE, 0,op,"Players:");
  255.     for(pl=first_player;pl!=NULL;pl=pl->next) {
  256.       if(pl->ob->map == NULL)
  257.         continue;
  258. /* Any reason one sprintf can't be used?  The are displaying all
  259.  * the same informaitn, except one display pl->ob->count.
  260.  */
  261.       if(op == NULL || QUERY_FLAG(op, FLAG_WIZ))
  262.         (void) sprintf(buf,"%s the %s (%s@%s) [%s]%s%s%s (%d)",pl->ob->name,
  263.         (pl->own_title[0]=='\0'?pl->title:pl->own_title),
  264.         pl->username,pl->name,
  265.         pl->ob->map->path,
  266.                 QUERY_FLAG(pl->ob,FLAG_WIZ)?" [WIZ]":"",pl->idle?" I":"",
  267.                 pl->peaceful?"P":"W",pl->ob->count);
  268.       else
  269.         (void) sprintf(buf,"%s the %s (%s@%s) [%s]%s%s%s",pl->ob->name,
  270.                  (pl->own_title[0]=='\0'?pl->title:pl->own_title),
  271.              pl->username,pl->name,
  272.          pl->ob->map->path,
  273.                  QUERY_FLAG(pl->ob,FLAG_WIZ)?" [WIZ]":"",pl->idle?" I":"",
  274.                  pl->peaceful?"P":"W");
  275.       new_draw_info(NDI_UNIQUE, 0,op,buf);
  276.     }
  277. #ifdef SERVER
  278.     if(first_socket == (sockets *) NULL)
  279.       return 1;
  280.     new_draw_info(NDI_UNIQUE, 0,op,"Sockets:");
  281.     for(s = first_socket; s != (sockets *) NULL; s = s->next) {
  282.       (void) sprintf(buf, "%s (%s)%s", s->name,s->host,s->wiz?" [Wiz]":"");
  283.       new_draw_info(NDI_UNIQUE, 0,op,buf);
  284.     }
  285. #endif
  286.     return 1;
  287.   }
  288.  
  289. int command_malloc (object *op, char *params)
  290. {
  291.     malloc_info(op);
  292.     return 1;
  293.   }
  294.  
  295. int command_mapinfo (object *op, char *params)
  296. {
  297.     current_map_info(op);
  298.     return 1;
  299.   }
  300.  
  301. int command_maps (object *op, char *params)
  302. {
  303.     map_info(op);
  304.     return 1;
  305.   }
  306.  
  307. int command_strings (object *op, char *params)
  308. {
  309.     ss_dump_statistics();
  310.     new_draw_info(NDI_UNIQUE, 0,op,errmsg);
  311.     new_draw_info(NDI_UNIQUE, 0,op,ss_dump_table(2));
  312.     return 1;
  313.   }
  314.  
  315. #ifdef DEBUG
  316. int command_sstable (object *op, char *params)
  317. {
  318.     ss_dump_table(1);
  319.     return 1;
  320.   }
  321. #endif
  322.  
  323. int command_time (object *op, char *params)
  324. {
  325.     time_info(op);
  326.     return 1;
  327.   }
  328.  
  329. int command_archs (object *op, char *params)
  330. {
  331.     arch_info(op);
  332.     return 1;
  333.   }
  334.  
  335. int command_hiscore (object *op, char *params)
  336. {
  337.     display_high_score(op,op==NULL?9999:(INFOLINES)-1);
  338.     return 1;
  339.   }
  340.  
  341. int command_debug (object *op, char *params)
  342. {
  343.     int i;
  344.     char buf[MAX_BUF];
  345.   if(params==NULL || !sscanf(params, "%d", &i)) {
  346.       sprintf(buf,"Global debug level is %d.",debug);
  347.       new_draw_info(NDI_UNIQUE, 0,op,buf);
  348.       if(op == NULL) {
  349.         sprintf(buf,"Socket debug level is %d.",active_socket->debug);
  350.         new_draw_info(NDI_UNIQUE, 0,op,buf);
  351.       }
  352.       return 1;
  353.     }
  354.   if((op != NULL && !QUERY_FLAG(op, FLAG_WIZ)) || (*params == '-' && !active_socket->wiz)) {
  355.       new_draw_info(NDI_UNIQUE, 0,op,"Privileged command.");
  356.       return 1;
  357.     }
  358.   if (*params == '-' || op != NULL)
  359.       debug = (enum LogLevel) FABS(i);
  360.     else
  361.       active_socket->debug = (enum LogLevel) i;
  362.     sprintf(buf,"Set debug level to %d.", i);
  363.     new_draw_info(NDI_UNIQUE, 0,op,buf);
  364.     return 1;
  365.   }
  366.  
  367.  
  368. /*
  369.  * Those dumps should be just one dump with good parser
  370.  */
  371.  
  372. int command_dumpbelow (object *op, char *params)
  373. {
  374.   if (op && op->below) {
  375.       dump_object(op->below);
  376.       new_draw_info(NDI_UNIQUE, 0,op,errmsg);
  377.       }
  378.   return 0;
  379. }
  380.  
  381. int command_wizpass (object *op, char *params)
  382. {
  383.   int i;
  384.  
  385.   if (!op)
  386.     return 0;
  387.  
  388.   if (!params)
  389.     i = (QUERY_FLAG(op, FLAG_WIZPASS)) ? 0 : 1;
  390.   else
  391.     i =onoff_value(params);
  392.  
  393.   if (i) {
  394.           new_draw_info(NDI_UNIQUE, 0,op, "You will now walk through walls.\n");
  395.       SET_FLAG(op, FLAG_WIZPASS);
  396.   } else {
  397.     new_draw_info(NDI_UNIQUE, 0,op, "You will now be stopped by walls.\n");
  398.     CLEAR_FLAG(op, FLAG_WIZPASS);
  399.   }
  400.   return 0;
  401. }
  402.  
  403. int command_dumpallobjects (object *op, char *params)
  404. {
  405.         dump_all_objects();
  406.   return 0;
  407. }
  408.  
  409. int command_dumpfriendlyobjects (object *op, char *params)
  410. {
  411.         dump_friendly_objects();
  412.   return 0;
  413. }
  414.  
  415. int command_dumplights (object *op, char *params)
  416. {
  417.     if(op) dump_map_lights(op->map);
  418.         return 0;
  419. }
  420.  
  421. int command_dumpallarchetypes (object *op, char *params)
  422. {
  423.         dump_all_archetypes();
  424.   return 0;
  425.       }
  426.  
  427. int command_ssdumptable (object *op, char *params)
  428. {
  429.       (void) ss_dump_table(1);
  430.   return 0;
  431. }
  432.  
  433. int command_dumpmap (object *op, char *params)
  434. {
  435.   if(op)
  436.         dump_map(op->map);
  437.   return 0;
  438. }
  439.  
  440. int command_dumpallmaps (object *op, char *params)
  441. {
  442.         dump_all_maps();
  443.   return 0;
  444. }
  445.  
  446. int command_printlos (object *op, char *params)
  447. {
  448.   if (op)
  449.         print_los(op);
  450.   return 0;
  451. }
  452.  
  453. int command_clearinfo (object *op, char *params)
  454. {
  455.  clear_win_info(op);
  456.  return 0;
  457. }
  458.  
  459. int command_refresh (object *op, char *params)
  460. {
  461.       if(!op->contr->split_window)
  462.         XClearWindow(op->contr->gdisp,op->contr->win_root);
  463.       refresh(op);
  464.       op->contr->last_value= -1;
  465.       draw_stats(op);
  466.       draw_all_info(op);
  467.       draw_all_inventory(op);
  468.       draw_all_look(op);
  469.       draw_all_message(op);
  470.   return 0;
  471. }
  472.  
  473. int command_version (object *op, char *params)
  474. {
  475.       version(op);
  476.   return 0;
  477. }
  478.  
  479.  
  480. #ifndef BUG_LOG
  481. #define BUG_LOG "bug_log"
  482. #endif
  483. void bug_report(char * reportstring){
  484.   FILE * fp;
  485.   if((fp = fopen( BUG_LOG , "a")) != NULL){
  486.       fprintf(fp,"%s\n", reportstring);
  487.       fclose(fp);
  488.   } else {
  489.       perror(BUG_LOG);
  490.   }
  491. }
  492.  
  493. int command_output_sync(object *op, char *params)
  494. {
  495.     int val;
  496.  
  497.     if (!params) {
  498.     new_draw_info_format(NDI_UNIQUE, 0, op,
  499.         "Output sync time is presently %d", op->contr->outputs_sync);
  500.     return 1;
  501.     }
  502.     val=atoi(params);
  503.     if (val>0) {
  504.     op->contr->outputs_sync = val;
  505.     new_draw_info_format(NDI_UNIQUE, 0, op,
  506.         "Output sync time now set to %d", op->contr->outputs_sync);
  507.     }
  508.     else
  509.     new_draw_info(NDI_UNIQUE, 0, op,"Invalid value for output_sync.");
  510.  
  511.     return 1;
  512. }
  513.  
  514. int command_output_count(object *op, char *params)
  515. {
  516.     int val;
  517.  
  518.     if (!params) {
  519.     new_draw_info_format(NDI_UNIQUE, 0, op,
  520.         "Output count is presently %d", op->contr->outputs_count);
  521.     return 1;
  522.     }
  523.     val=atoi(params);
  524.     if (val>0) {
  525.     op->contr->outputs_count = val;
  526.     new_draw_info_format(NDI_UNIQUE, 0, op,
  527.         "Output count now set to %d", op->contr->outputs_count);
  528.     }
  529.     else
  530.     new_draw_info(NDI_UNIQUE, 0, op,"Invalid value for output_count.");
  531.  
  532.     return 1;
  533. }
  534.  
  535. int command_listen (object *op, char *params)
  536. {
  537.   int i;
  538.  
  539.   if(params==NULL || !sscanf(params, "%d", &i)) {
  540.     new_draw_info_format(NDI_UNIQUE, 0, op,
  541.     "Set listen to what (presently %d)?", 
  542.     op==NULL? active_socket->listen_lev : (int) op->contr->listening);
  543.       return 1;
  544.     }
  545.     if(op == NULL) {
  546.       active_socket->listen_lev = i;
  547.       new_draw_info(NDI_UNIQUE, 0,op,"OK.");
  548.     }
  549.     else {
  550.       op->contr->listening=(char) i;
  551.       new_draw_info_format(NDI_UNIQUE, 0, op,
  552.     "Your verbose level is now %d.",i);
  553.     }
  554.     return 1;
  555. }
  556.  
  557. int command_keyboard_flush (object *op, char *params)
  558. {
  559.   if (!params)
  560.     op->contr->keyboard_flush =!op->contr->keyboard_flush;
  561.   else
  562.     op->contr->keyboard_flush =onoff_value(params);
  563.  
  564.   if(op->contr->keyboard_flush)
  565.     new_draw_info(NDI_UNIQUE, 0,op, "Keystrokes will not be buffered.");
  566.   else
  567.     new_draw_info(NDI_UNIQUE, 0,op, "Keystrokes will be buffered.");
  568.  
  569.   return 0;
  570. }
  571.  
  572. int command_show_inv_icon(object *pl, char *params)
  573. {
  574.   if (!params)
  575.     pl->contr->show_inv_icon =!pl->contr->show_inv_icon;
  576.   else
  577.     pl->contr->show_inv_icon =onoff_value(params);
  578.  
  579.   if(pl->contr->show_inv_icon) {
  580.     new_draw_info(NDI_UNIQUE, 0,pl, "Inventory icons will now be shown");
  581.     pl->contr->inv_chars=(pl->contr->invhint.width-88)/FONTWIDTH;
  582.  
  583.   }
  584.   else {
  585.     new_draw_info(NDI_UNIQUE, 0,pl, "Inventory icons will not be shown");
  586.     pl->contr->inv_chars=(pl->contr->invhint.width-60)/FONTWIDTH;
  587.   }
  588.   sprintf(pl->contr->format_inv,"%%-%d.%ds%%-6s",pl->contr->inv_chars-6,
  589.       pl->contr->inv_chars-6);
  590.   draw_all_inventory(pl);
  591.   return 0;
  592. }
  593.  
  594.